﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Model;

namespace PJRScrum
{
    public partial class ImportGuiPanelThree : ImportGuiPanel
    {
        Image origImg;
        public void SetImage(Image img)
        {
            origImg = img;
        }

        public ImportGuiPanelThree()
        {
            InitializeComponent();
            label1.Visible = false;
            nud_aantMeter.Visible = false;
            nud_aantMeter.Visible = false;
            pictureBox8.MouseMove += new MouseEventHandler(pictureBox8_MouseMove);
            pictureBox8.MouseDown += new MouseEventHandler(pictureBox8_MouseDown);
            pictureBox8.MouseUp += new MouseEventHandler(pictureBox8_MouseUp);
            btn_klaar.Click += new EventHandler(btn_klaarMetRekken_Click);
            zoompercentage = 100;
            nud_aantMeter.Controls[0].Hide();
            nud_aantMeter.Controls[0].Hide();
            toevoegOptie = ToevoegOptie.REK;
            resetCategorieToevoegen();
        }

        void btn_klaarBevestig_Click(object sender, EventArgs e)
        {
            if (huidigZijde != null)
            {
                double dist = Punt.distBetween(huidigZijde.PuntEen, huidigZijde.PuntTwee);
                schaal = (double)nud_aantMeter.Value / dist;
                btn_klaar.Click -= btn_klaarBevestig_Click;
                nud_aantMeter.Hide();
                label1.Hide();
                nud_aantMeter.Hide();
                btn_klaar.Text = "Klaar met schappen";
                btn_klaar.Click += new EventHandler(btn_klaarMetSchappen_Click);
                btnBevestig.Visible = false;
                huidigZijde = null;
                toevoegOptie = ToevoegOptie.SCHAP;
            }
        }

        public void Redraw()
        {
            tekenWinkel(punten);
        }

        enum ToevoegOptie
        {
            REK,
            SCHAP,
            POIToevoegen,
            SchapPOIToevoegen,
            POILinken,
            SCHAAL,
            NIETS
        }

        #region Fields
        ToevoegOptie toevoegOptie;
        double zoompercentage;//zoompercentage panel 8
        private int rekPuntenCount; //Aantal punten van rek wordt hier bijgehouden   
        private List<Point> selected = new List<Point>();
        List<Rek> gebouwdeRekken = new List<Rek>();
        Punt[] punt = new Punt[4];
        Point[] punten;
        bool rekGemaakt;
        bool[] klik = new bool[4];
        Graphics tempGraphics;
        //List<Point[]> rekken
        #endregion


        private void resetCategorieToevoegen()
        {
            chklist_toeTeVoegenCategorien.Items.Clear();
            foreach (String s in View.GetInstance().LaadCategorie())
            {
                chklist_toeTeVoegenCategorien.Items.Add(s);
            }
        }

        Zijde huidigZijde; //De zijde die momenteel veranderd wordt
        bool isMouseDown;
        void pictureBox8_MouseUp(object sender, MouseEventArgs e)
        {
            Point plaats = e.Location;
            //RelatiefNaarDaadwerkelijk(new Point(e.X, e.Y));
            //plaats = DaadwerkelijkNaarRelatief(plaats);
            isMouseDown = false;
            switch (toevoegOptie)
            {
                case ToevoegOptie.REK:
                    for (int i = 0; i < klik.Length; i++)
                    {
                        if (klik[i])
                        {
                            //punt bewaart de punten om te tekenen, en hoeven dus geen daadwerkelijke waardes te hebben
                            punt[i].setCoords(plaats.X, plaats.Y);
                            if (punten != null && punten[i] != null) //punten bewaart alle daadwerkelijke Points, dus hier relatiefNaarDaadwerkelijk voor t veranderen
                                punten[i] = RelatiefNaarDaadwerkelijk(plaats);
                            klik[i] = false;
                        }
                    }
                    break;
                case ToevoegOptie.SCHAP:
                    if (huidigZijde != null) //we zijn al met een zijde bezig dus breaken
                        break;
                    foreach (Rek r in gebouwdeRekken)
                    {
                        if (r.ZitInRek(RelatiefNaarDaadwerkelijk(plaats)))
                        {
                            foreach (Zijde z in r.Zijden)
                            {
                                if (z.Geactiveert)
                                    continue;
                                huidigZijde = z;
                                pnl_categorieToevoegen.Visible = true;
                                tekenWinkel(punten);
                                return;
                            }
                        }
                    }
                    break;
                case ToevoegOptie.POIToevoegen:
                case ToevoegOptie.SchapPOIToevoegen:
                    if (huidigPOI != null)
                    {
                        huidigPOI.Plaats = RelatiefNaarDaadwerkelijk(plaats);
                    }
                    break;
                default:
                    break;
            }
            tekenWinkel(punten);
        }

        public override bool Finished
        {
            get
            {
                return finished;
            }
        }

        List<Point> Punten = new List<Point>();
        List<Point[]> poiLinks = new List<Point[]>();
        void pictureBox8_MouseDown(object sender, MouseEventArgs e)
        {
            Point plaats = e.Location;//RelatiefNaarDaadwerkelijk(new Point(e.X, e.Y));
            //plaats = DaadwerkelijkNaarRelatief(plaats);
            isMouseDown = true;
            switch (toevoegOptie)
            {
                case ToevoegOptie.REK:
                    if (!rekGemaakt)
                    {
                        //t.Start();
                        //Punten bewaart de daadwerkelijke Points
                        Punten.Add(RelatiefNaarDaadwerkelijk(plaats));
                        rekPuntenCount++;
                        punt[rekPuntenCount - 1] = new Punt(plaats.X, plaats.Y);
                        klik[rekPuntenCount - 1] = true;
                        btnZoomIn.Enabled = false;
                        btnZoomOut.Enabled = false;

                        if (rekPuntenCount == 4)
                        {
                            punten = new Point[4];
                            for (int i = 0; i < 4; i++)
                            {
                                Point temp = Punten[i];
                                punten[i] = temp;
                            }
                            rekGemaakt = true;
                            Punten.Clear();
                            // t.Start();
                        }
                    }
                    else
                    {
                        Point pMuis = e.Location;
                        for (int i = 0; i < punt.Length; i++)
                        {
                            if (punt[i] != null && punt[i].Check(pMuis))
                            {
                                klik[i] = true;
                                break;
                            }
                        }
                    }
                    break;
                case ToevoegOptie.SCHAAL:
                    Point p = RelatiefNaarDaadwerkelijk(plaats);
                    foreach (Rek r in gebouwdeRekken)
                        foreach (Zijde z in r.Zijden)
                        {
                            Point p1 = z.PuntEen;
                            Point p2 = z.PuntTwee;
                            int minX = Math.Min(p1.X, p2.X);
                            int maxX = Math.Max(p1.X, p2.X);
                            int minY = Math.Min(p1.Y, p2.Y);
                            int maxY = Math.Max(p1.Y, p2.Y);
                            if (minX < p.X && p.X < maxX && minY < p.Y && p.Y < maxY)
                            {
                                huidigZijde = z;
                                return;
                            }
                        }

                    break;
                case ToevoegOptie.SCHAP:
                    break;
                case ToevoegOptie.POIToevoegen:
                    if (huidigPOI == null)
                    {
                        huidigPOI = new POI(RelatiefNaarDaadwerkelijk(plaats), gebouwdePois.Count);
                    }
                    break;
                case ToevoegOptie.SchapPOIToevoegen:
                    if (huidigZijde != null)
                    {
                        if (huidigPOI == null)
                        {
                            huidigPOI = new POI(RelatiefNaarDaadwerkelijk(plaats), gebouwdePois.Count);
                        }
                    }
                    break;
                case ToevoegOptie.POILinken:
                    POI tempPoi = null;
                    foreach (POI poi in gebouwdePois)
                    {
                        if (Punt.Check(poi.Plaats, RelatiefNaarDaadwerkelijk(plaats)))
                        {
                            tempPoi = poi;
                            break;
                        }
                    }
                    if (tempPoi != null)
                    {
                        if (huidigPOI == null)
                        {
                            huidigPOI = tempPoi;
                        }
                        else
                        {
                            int idx1 = gebouwdePois.IndexOf(tempPoi);
                            int idx2 = gebouwdePois.IndexOf(huidigPOI);
                            int dist = (int)(Punt.distBetween(tempPoi.Plaats, huidigPOI.Plaats) * schaal);
                            tempPoi.Kinderen.Add(new Kind(idx2, dist));
                            huidigPOI.Kinderen.Add(new Kind(idx1, dist));
                            Point[] ps = new Point[2];
                            ps[0] = tempPoi.Plaats;
                            ps[1] = huidigPOI.Plaats;
                            poiLinks.Add(ps);
                            huidigPOI = null;
                        }
                    }
                    break;
                default:
                    break;
            }
            tekenWinkel(punten);
        }


        #region  Wizard en Form elementen
        /// <summary>
        /// Zoomt in op afbeelding in panel3
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnZoomIn_Click(object sender, EventArgs e)
        {
            if (zoompercentage < 250)
            {
                zoompercentage += 10;
                Zoom();
            }

        }

        /// <summary>
        /// Zoomt uit op afbeelding in panel3
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnZoomOut_Click(object sender, EventArgs e)
        {
            if (zoompercentage > 10) { zoompercentage -= 10; Zoom(); }
        }
        #endregion

        #region Plattegrond onderdelen (Zoomen etc.)
        /// <summary>
        /// Zoomt in met de algemene zoomfactor
        /// </summary>
        private void Zoom()
        {
            tekenWinkel(punten);
            //Update img dmv tekenRek ipv PlattegrondTonen ivm de rekken
            //Size formaat = new Size((int)((zoompercentage / 100) * layer.Original.Width), (int)((zoompercentage / 100) * layer.Original.Height));
            //Bitmap zoomedImg = new Bitmap(layer.Original, formaat);
            int hPercentage = hScrollBar1.Maximum;
            int vPercentage = vScrollBar1.Maximum;
            //PlattegrondTonen(zoomedImg);
            vScrollBar1.Value = (vScrollBar1.Value * vScrollBar1.Maximum) / vPercentage;
            hScrollBar1.Value = (hScrollBar1.Value * hScrollBar1.Maximum) / hPercentage;
            schuiven(-vScrollBar1.Value, -hScrollBar1.Value);

        }

        private Size getZoomFormaat()
        {
            return new Size((int)((zoompercentage / 100) * origImg.Width), (int)((zoompercentage / 100) * origImg.Height));
        }

        /// <summary>
        /// Rekent om waar er daadwerkelijk op de afbeelding heen wordt gewezen
        /// </summary>
        /// <param name="plaats">De om te rekenen plaats</param>
        /// <returns></returns>
        private Point RelatiefNaarDaadwerkelijk(Point plaats)
        {
            plaats.Y = (int)((plaats.Y / zoompercentage) * 100);
            plaats.X = (int)((plaats.X / zoompercentage) * 100);
            return plaats;
        }

        private Point DaadwerkelijkNaarRelatief(Point plaats)
        {
            plaats.Y = (int)((plaats.Y * zoompercentage) / 100);
            plaats.X = (int)((plaats.X * zoompercentage) / 100);
            return plaats;
        }

        /// <summary>
        /// Toont de gegeven afbeelding op het plattegrond vlak.
        /// </summary>
        /// <param name="image">De plattergrond</param>
        private void PlattegrondTonen(Image image)
        {
            btnZoomIn.Visible = true;
            btnZoomOut.Visible = true;
            if (panel8.Height <= image.Height)
            {
                vScrollBar1.Maximum = image.Height - panel8.Height;
                vScrollBar1.Visible = true;
            }
            else { vScrollBar1.Visible = false; }
            if (panel8.Width <= image.Width)
            {
                hScrollBar1.Maximum = image.Width - panel8.Width;
                hScrollBar1.Visible = true;
            }
            else { hScrollBar1.Visible = false; }
            pictureBox8.Image = image;
        }

        private void vScrollBar1_Scroll(object sender, ScrollEventArgs e)
        {
            schuiven((-vScrollBar1.Value), pictureBox8.Left);
        }

        private void hScrollBar1_Scroll(object sender, ScrollEventArgs e)
        {
            schuiven(pictureBox8.Top, (-hScrollBar1.Value));
        }

        /// <summary>
        /// Regelt het verschuiven van de plattegrond
        /// </summary>
        /// <param name="Top">Hoeveel er vanuit de top verschoven moet worden</param>
        /// <param name="Left">Hoeveel er vanuit de linker zijde verschoven moet worden</param>
        private void schuiven(int Top, int Left)
        {
            pictureBox8.Top = Top;
            pictureBox8.Left = Left;
        }

        /// <summary>
        /// Zorgt ervoor dat er een crosshair op de punten komt
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pictureBox8_MouseMove(object sender, MouseEventArgs e)
        {
            Point plaats = e.Location;// RelatiefNaarDaadwerkelijk(new Point(e.X, e.Y));
            //plaats = DaadwerkelijkNaarRelatief(plaats);
            switch (toevoegOptie)
            {
                case ToevoegOptie.REK:
                    if (isMouseDown)
                    {
                        for (int i = 0; i < klik.Length; i++)
                        {
                            if (klik[i])
                            {
                                punt[i].setCoords(plaats.X, plaats.Y);
                                if (punten != null && punten[i] != null)
                                    punten[i] = RelatiefNaarDaadwerkelijk(e.Location);
                            }
                        }
                    }
                    Point pMuis = e.Location;

                    for (int i = 0; i < punt.Length; i++)
                    {
                        if (punt[i] != null && punt[i].Check(pMuis))
                        {
                            this.Cursor = Cursors.Cross;
                            return;
                        }
                    }
                    this.Cursor = Cursors.Arrow;
                    break;
                case ToevoegOptie.SCHAP:
                    break;
                case ToevoegOptie.POIToevoegen:
                case ToevoegOptie.SchapPOIToevoegen:
                    if (isMouseDown)
                    {
                        if (huidigPOI != null)
                        {
                            huidigPOI.Plaats = RelatiefNaarDaadwerkelijk(plaats);
                        }
                    }
                    break;
                default:
                    break;
            }
            if (isMouseDown)
                tekenWinkel(punten);
        }

        bool firstDraw = true;
        private void tekenWinkel(Point[] huidigRekPunten)
        {
            Bitmap img = new Bitmap(origImg, getZoomFormaat());
            //v.Plattegrond = (Bitmap)pictureBox8.Image;
            tempGraphics = Graphics.FromImage(img);
            //temp.Clear(Color.White);
            SolidBrush transparantBlueBrush = new SolidBrush(Color.FromArgb(25, Color.Blue));
            if (huidigRekPunten != null)
            {
                Point[] fixedPoints = new Point[huidigRekPunten.Length];
                for (int i = 0; i < huidigRekPunten.Length; i++)
                {
                    fixedPoints[i] = DaadwerkelijkNaarRelatief(huidigRekPunten[i]);
                }
                tempGraphics.FillPolygon(transparantBlueBrush, fixedPoints);
            }
            SolidBrush blueBrush = new SolidBrush(Color.Blue);
            Pen redPen = new Pen(Color.Red, 5);
            Pen orangePen = new Pen(Color.Orange, 5);
            Pen greenPen = new Pen(Color.Green, 5);

            foreach (Rek rek in gebouwdeRekken)
            {
                Point[] fixedPoints = new Point[rek.Punten.Length];
                for (int i = 0; i < rek.Punten.Length; i++)
                {
                    fixedPoints[i] = DaadwerkelijkNaarRelatief(rek.Punten[i]);
                }
                tempGraphics.FillPolygon(transparantBlueBrush, fixedPoints);
                foreach (Zijde z in rek.Zijden)
                {
                    if (!z.Geactiveert)
                    {
                        tempGraphics.DrawLine(redPen, DaadwerkelijkNaarRelatief(z.PuntEen), DaadwerkelijkNaarRelatief(z.PuntTwee));
                    }
                    else
                    {
                        tempGraphics.DrawLine(greenPen, DaadwerkelijkNaarRelatief(z.PuntEen), DaadwerkelijkNaarRelatief(z.PuntTwee));
                    }
                }
            }
            if (huidigZijde != null)
                tempGraphics.DrawLine(orangePen, DaadwerkelijkNaarRelatief(huidigZijde.PuntEen), DaadwerkelijkNaarRelatief(huidigZijde.PuntTwee));

            for (int i = 0; i < punt.Length; i++)
            {
                if (punt[i] != null)
                {
                    tempGraphics.FillEllipse(blueBrush, (float)punt[i].X - 5, (float)punt[i].Y - 5, 10, 10);
                }
            }
            Brush greenBrush = Brushes.Green;
            Brush orangeBrush = Brushes.Orange;
            foreach (POI poi in gebouwdePois)
            {
                Point temp = DaadwerkelijkNaarRelatief(poi.Plaats);
                tempGraphics.FillEllipse(greenBrush, temp.X - 5, temp.Y - 5, 10, 10);
            }
            if (huidigPOI != null)
            {
                Point temp = DaadwerkelijkNaarRelatief(huidigPOI.Plaats);
                tempGraphics.FillEllipse(orangeBrush, temp.X - 5, temp.Y - 5, 10, 10);
            }
            foreach (Point[] ps in poiLinks)
                tempGraphics.DrawLine(Pens.Black, DaadwerkelijkNaarRelatief(ps[0]), DaadwerkelijkNaarRelatief(ps[1]));
            Image tempImg = pictureBox8.Image;
            PlattegrondTonen(img);
            if (firstDraw)
                firstDraw = false;
            else
                tempImg.Dispose();
            tempGraphics.Dispose();
        }

        private void btnBevestig_Click(object sender, EventArgs e) //nieuw rek kunnen plaatsen
        {
            if (!rekGemaakt)
                return;
            //PlattegrondTonen(layer.Original);
            //rekken.Add(punten); gebruik gebouwdeRekken met de daadwerkelijke rekken ipv slechts de punten
            Rek rek = new Rek(punten, gebouwdeRekken.Count);
            for (int i = 0; i < 4; i++)
            {
                Zijde z = new Zijde(punten[i], punten[(i + 1) % 4], i);
                rek.Zijden.Add(z);
            }
            gebouwdeRekken.Add(rek);
            View.GetInstance().VoegRekToe(rek); //Nog niet zeker of het rek hier toegevoegd moet worden, rek heeft nog geen zijden, schappen, artikelen!!!!
            rekPuntenCount = 0;
            punten = null;
            punt = new Punt[4];
            btnZoomIn.Enabled = true;
            btnZoomOut.Enabled = true;
            rekGemaakt = false;
            tekenWinkel(punten);
        }

        #endregion

        #region Producten toevoegen/verwijderen

        private void buttonNieuwProduct_Click(object sender, EventArgs e)
        {
            ImporteerArtikel importeerArtikel = new ImporteerArtikel();
            importeerArtikel.ShowDialog();
        }

        private void buttonVerwijderProduct_Click(object sender, EventArgs e)
        {
            VerwijderArtikel verwijderArtikel = new VerwijderArtikel();
            verwijderArtikel.ShowDialog();
        }

        #endregion

        private void btn_klaarMetRekken_Click(object sender, EventArgs e)
        {
            if (rekPuntenCount > 0)
            {
                MessageBox.Show("U kunt niet klaar zijn met rekken als u nog een rek bent aan het bouwen.");
                return;
            }
            if (gebouwdeRekken.Count == 0)
            {
                MessageBox.Show("U heeft nog geen rek toegevoegd.");
                return;
            }
            //crappy manier om aan te geven dat schappen worden toegevoegd
            rBRekken.Checked = false;
            rBSchappen.Checked = true;
            toevoegOptie = ToevoegOptie.SCHAAL;
            //huppakee lekker lelijk
            btnBevestig.Visible = false;
            nud_aantMeter.Visible = true;
            label1.Visible = true;
            //rekken shine is gedaan, nu door naar schappen
            btn_klaar.Click -= btn_klaarMetRekken_Click;
            btn_klaar.Click += btn_klaarBevestig_Click;
            btn_klaar.Text = "Bevestig de schaal";
        }

        void btn_klaarMetSchappen_Click(object sender, EventArgs e)
        {
            foreach (Rek r in gebouwdeRekken)
                foreach (Zijde z in r.Zijden)
                    if (!z.Geactiveert)
                    {
                        MessageBox.Show("U heeft nog niet alle zijden gespecificeerd");
                        return;
                    }
            btn_bevestigCategorien.Click -= btn_bevestigCategorien_Click;
            btn_klaar.Click -= btn_klaarMetSchappen_Click;
            btnBevestig.Click -= btnBevestig_Click;
            btnBevestig.Visible = true;
            btnBevestig.Click += new EventHandler(btnBevestigPoi_Click);
            btn_klaar.Click += new EventHandler(btn_klaarMetLoopPOI_Click);
            btn_klaar.Text = "Klaar met wandel punten";
            toevoegOptie = ToevoegOptie.POIToevoegen;
        }

        public void btnBevestigPoi_Click(object sender, EventArgs e)
        {
            if (huidigPOI == null)
            {
                MessageBox.Show("U moet eerst een POI plaatsen om te kunnen bevestigen");
                return;
            }
            gebouwdePois.Add(huidigPOI);
            huidigPOI = null;
            tekenWinkel(punten);
        }

        List<POI> gebouwdePois = new List<POI>();
        POI huidigPOI;
        public void btn_bevestigSchapPOI_Click(object sender, EventArgs e)
        {
            if (huidigPOI != null)
            {
                huidigPOI.Artikelen.AddRange(huidigZijde.Schappen[0].Artikelen);
                huidigZijde.Geactiveert = true;
                huidigZijde = getNextZijde();
                gebouwdePois.Add(huidigPOI);
                huidigPOI = null;
            }
            tekenWinkel(punten);
        }

        void btn_klaarMetLoopPOI_Click(object sender, EventArgs e)
        {
            if (huidigPOI != null)
            {
                MessageBox.Show("U moet de huidige POI nog bevestigen");
                return;
            }
            if (gebouwdePois.Count < 1)
            {
                MessageBox.Show("U heeft nog geen enkele POI toegevoegd.");
                return;
            }
            toevoegOptie = ToevoegOptie.SchapPOIToevoegen;
            rBPoiLinken.Checked = true;
            foreach (Rek r in gebouwdeRekken)
                foreach (Zijde z in r.Zijden)
                    z.Geactiveert = false;
            btn_klaar.Click -= btn_klaarMetLoopPOI_Click;
            btn_klaar.Click += new EventHandler(btn_klaarMetSchapPOI_Click);
            btnBevestig.Click -= btnBevestigPoi_Click;
            btnBevestig.Click += new EventHandler(btn_bevestigSchapPOI_Click);
            btn_klaar.Text = "Klaar met schappen POI's";
            huidigZijde = getNextZijde();
            tekenWinkel(punten);
        }

        Zijde getNextZijde()
        {
            foreach (Rek r in gebouwdeRekken)
                foreach (Zijde z in r.Zijden)
                    if (!z.Geactiveert)
                        return z;
            return null;
        }

        void btn_klaarMetSchapPOI_Click(object sender, EventArgs e)
        {
            if (huidigZijde != null)
            {
                MessageBox.Show("U heeft nog geen POI gemaakt voor iedere zijde.");
                return;
            }
            toevoegOptie = ToevoegOptie.POILinken;
            btn_klaar.Click -= btn_klaarMetSchappen_Click;
            btn_klaar.Click += new EventHandler(btn_klaarMetPoiLinken_Click);
            btn_klaar.Text = "Klaar met POI's linken";
        }

        bool finished;
        private double schaal;
        void btn_klaarMetPoiLinken_Click(object sender, EventArgs e)
        {
            foreach (POI p in gebouwdePois)
                View.GetInstance().VoegPOIToe(p);
            btn_klaar.Visible = false;
            btnBevestig.Visible = false;
            toevoegOptie = ToevoegOptie.NIETS;
            finished = true;
        }

        private void btn_bevestigCategorien_Click(object sender, EventArgs e)
        {
            if (huidigZijde != null)
            {
                Schap schap = new Schap(huidigZijde.PuntEen, huidigZijde.PuntTwee, 0);
                if (chklist_toeTeVoegenCategorien.SelectedItems.Count > 0)
                {
                    //TODO: Meerdere schappen per zijde
                    foreach (String s in chklist_toeTeVoegenCategorien.SelectedItems)
                    {
                        schap.Artikelen.AddRange(View.GetInstance().LaadArtikelen(s));
                    }
                    //TODO artikelen/categorie toevoegen aan schap

                }

                huidigZijde.VoegSchapToe(schap);
                huidigZijde.Geactiveert = true;
                huidigZijde = null;
                pnl_categorieToevoegen.Visible = false;
            }
            tekenWinkel(punten);
        }


    }
}
